home *** CD-ROM | disk | FTP | other *** search
/ PD ROM 1 / PD ROM Volume I - Macintosh Software from BMUG (1988).iso / Graphics / Graphic Demos / PseudoPS / SimpleTools.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-08-26  |  39.8 KB  |  1,452 lines  |  [TEXT/KAHL]
  1. /*
  2.     Title    : SimpleTools2.c
  3.     Author    : Erik Kilk  Copyright 1985, 1986
  4.     Date    : June 7, 1985, June 3, 1986, November 8, 1986
  5.           November 28, 1986
  6.     
  7.     SimpleTools is a collection of routines to aid programming
  8.     simple "Macintosh looking" programs.  SimpleTools initializes
  9.     the toolbox, monitors & acts upon events, and provides generic
  10.     i/o routines for your application.  You initialize your program
  11.     by letting SimpleTools know what windows and menus you want along
  12.     with what functions SimpleTools should call when they are
  13.     selected.
  14.     
  15.     The purpose of SimpleTools is to encourage you to program those
  16.     simple programs or to pilot larger programs which you may not
  17.     do due to the enormous effort required to use the Macintosh
  18.     toolbox.  My goal was to study Inside Macintosh once to
  19.     Create SimpleTools and then be able to forget most of the usages
  20.     of the Toolbox routines.  Instead of thumbing through hundreds of
  21.     pages of Inside Macintosh just to get something up and running,
  22.     one need only remember a dozen generic calls.
  23.  
  24.     SimpleTools is very powerful, yet also very simple to use.  One
  25.     can get a program up and running with desk accessories, windows,
  26.     and menus in only a few minutes.  Advance features of SimpleTools
  27.     allow you to retrieve enough information from SimpleTools to call
  28.     any of the toolbox routines manually if need be.  
  29.     
  30.     
  31. =========================================================================
  32.  
  33.     You may use, study, copy, and freely distribute SimpleTools if:
  34.         1)  You mention "Programmed with the aid of SimpleTools
  35.             (c) Erik Kilk 1986" in your About... window of all
  36.             programs distributed free, share, or marketted.
  37.         2)  You register by sending $20 or more to:
  38.             Erik Kilk
  39.             4949 Snyder Lane, #247
  40.             Rohnert Park, CA  94928
  41.             (707) 794-2424 weekday afternoons
  42.             to encourage me to maintain and improve SimpleTools.
  43.             
  44. ==>    For a diskette including the most recent version of SimpleTools, 
  45.     several detailed examples of using SimpleTools, and a MacWrite file
  46.     describing SimpleTools and its use in more detail, send me a
  47.     diskette with enough stamps to mail it back to you.  Make sure you
  48.     have registered as stated above.
  49.         
  50.     This is 128k, MFS, HFS, old ROM, new ROM, Mac+, & TMON compatible.
  51.     This file compiles and executes with Megamax 3.0 beta and
  52.     LightSpeed 2.1.  Adjust the definition in simple.h for your
  53.     compiler.  When porting to other compilers, pay particular
  54.     attention to where the Lightspeed and Megamax code is specified
  55.     since these places are the likely problem areas.
  56.     
  57.     LIGHTSPEED NOTE:
  58.     
  59.     Drag SimpleTools out of the main segment in your project window.
  60.     You do this by dragging it below the dotted horizontal Line in the
  61.     project window.
  62.     
  63.  
  64. #include "simple.h"            /* define compiler in here    */
  65.  
  66. #ifdef MEGAMAX                            
  67.         overlay "simpletools"        /* compiler dependent        */
  68.  
  69.     #include <mem.h>
  70.     #include <qd.h>
  71.     #include <qdvars.h>
  72.     #include <misc.h>
  73.     #include <event.h>
  74.     #include <res.h>
  75.     #include <win.h>
  76.     #include <dialog.h>
  77.     #include <menu.h>
  78.     #include <string.h>
  79.     #include <stdio.h>
  80.     #include <pack.h>
  81.     #include <te.h>
  82.     #include <toolbox.h>
  83.     
  84.     #define  ZZ    &
  85. #else
  86.     #include <MemoryMgr.h>
  87.     #include <Quickdraw.h>
  88.     #include <EventMgr.h>
  89.     #include <ResourceMgr.h>
  90.     #include <WindowMgr.h>
  91.     #include <TextEdit.h>
  92.     #include <DialogMgr.h>
  93.     #include <MenuMgr.h>
  94.     #include <strings.h>
  95.     #include <stdio.h>
  96.     #include <PackageMgr.h>
  97.     #include <ToolboxUtil.h>
  98.     #include <StdFilePkg.h>
  99.     #include <pascal.h>
  100.     
  101.     #define  ZZ    
  102. #endif
  103.  
  104. #define TRUE (-1)        /* local definitions             */
  105. #define FALSE 0
  106. #define maxsruns 50        /* procedure table size            */
  107. #define MESSN 30        /* array size for message dialog items    */
  108. #define QUESN 40        /* array size for prompt dialog items    */
  109. #define ROM85   0x28E        /* new rom stuff             */
  110. #define NEWROM  0x7FFF
  111. #define inzoomout 8
  112. #define inzoomin  7
  113. #define zoomproc  8
  114.  
  115. typedef struct {            /* structure for an Item    */
  116.     char        itemname[40];
  117.     int        itemno;        /* Item number within menu     */
  118.     int        menuId;        /* menu id            */
  119.     MenuHandle    menuhand;    /* Item's menu's Handle                 */
  120.     ProcPtr        menurun;    /* procedure to run         */
  121.     Ptr        next;        /* pointer to the next Item     */
  122. } itemdatum;
  123.  
  124. typedef struct {            /* structure for a menu     */
  125.     char         menuname[20];    /* to allow reference by name     */
  126.     int         menuId;        /* menu id             */
  127.     MenuHandle    menuhand;    /* menu Handle to reference menu*/
  128.     itemdatum    **itemlist;    /* pointer to the list of items */
  129.     Ptr         next;        /* pointer to the next menu     */
  130. } menudatum;
  131.  
  132. typedef struct {            /* structure for a window     */
  133.     char        windname[80];    /* window's name and reference     */
  134.     WindowPtr    wptr;        /* window's pointer reference     */
  135.     ProcPtr    wact;            /* the activate procedure     */
  136.     ProcPtr    wdeact;            /* the deactivate procedure     */
  137.     ProcPtr    wupdate;        /* the update procedure     */
  138.     ProcPtr    wcontent;        /* the content procedure     */
  139.     Ptr        next;        /* pointer to the next window     */
  140. } winddatum;
  141.  
  142. #ifdef LIGHTSPEED
  143.   pascal Boolean     *TrackBox() = 0xA83B; 
  144.   pascal void         *ZoomWindow() = 0xA83A;
  145. #endif
  146.  
  147. WindowPtr windowpoint();
  148.  
  149. /* Local variables */
  150.  
  151. menudatum     **simplemenus;        /* Handle to menu data         */
  152. char         accname[80];        /* desk accessory name to open     */
  153. Rect         dragrect, sizerect;    /* limits for moving windows     */
  154. Rect         swholescreen;
  155. winddatum    **simplewinds;        /* Handle to window data     */
  156. int        firstwind;        /* if no windows have been made    */
  157. ProcPtr     simpleruns[maxsruns];    /* list of procedures to run     */
  158. WindowPtr    debugw;            /* window pointer for debugging */
  159. int        snewrom;
  160. int        getlinecaps = FALSE;
  161.  
  162. /************************************************************************/
  163. /* GLOBAL USER MODIFIABLE VARIABLES                     */
  164. /* These are variables that you can declare extern so that you can use    */
  165. /* them to change the SimpleTools defaults                */
  166. /************************************************************************/
  167.  
  168. /* wprocid = type of window to Create on next window() call        */
  169. /* For LightSpeed C, use a lower case d and upper case P for         */
  170. /*     DocumentProc.  Megamax conversion program does this wrong.    */
  171.  
  172. int         wprocid = documentProc;    
  173.  
  174. /* dogoaway = is the next created window to have a go-away box        */
  175.  
  176. int         dogoaway = TRUE;    
  177.  
  178. /* keydownproc = the procedure to be called when keyDown is detected    */
  179. /* autokeyproc = the procedure to be called when autoKey is detected    */
  180. /* BOTH OF THESE ARE PASSED THE EVENTRECORD SO THE KEY CAN BE FOUND    */
  181.  
  182. ProcPtr     keydownproc,
  183.           autokeyproc;         
  184.         
  185. /* applestring = a string containing the Apple for menu reference    */
  186.  
  187. char         applestring[2] 
  188.           = {'\024', '\0'};     
  189.  
  190. /* windmenu = does the next window created get a choice under the
  191.               window menu (so a closed window can be brought back    */
  192.               
  193. int         windmenu = TRUE;    
  194.  
  195. /* sizeredraw = is the window's content area erased and made
  196.                 updateable upon being resized                */
  197.                 
  198. int        sizeredraw = FALSE;    
  199.  
  200. /* show_new_window = does the created window get displayed right away
  201.         on the screen, if not, then it is hidden        */
  202.         
  203. int        show_new_window = TRUE;
  204.  
  205.  
  206. /******************************************************************/
  207. /* Dialog lists.  These were calculated by using the new resource */
  208. /* editor to make a template for a dialog and then using fedit to */
  209. /* list the hex listing of the Item list for the dialog.      */
  210. /******************************************************************/
  211.  
  212. int messd[MESSN] = {2,0,0,0x38,0xf1,0x4c,0x12d,0x402,0x4f4b,0,0,5,5,
  213.         0x36,0x12d,0x800,0,0,0x38,0xac,0x4c,0xe8,0x406,
  214.         0x4361,0x6e63,0x656c};
  215. int quesd[QUESN] = {3,0,0,0x21,0xf0,0x35,0x12c,0x402,0x4f4b,0,0,8,8,
  216.         0x28,0xe8,0x800,0,0,0x2b,8,0x4b,0xe8,0x1000,0,0,
  217.         8,0xf0,0x1c,0x12c,0x406,0x4361,0x6e63,0x656c};
  218.         
  219.         
  220. /* Local procedure */
  221.  
  222. void stnop()                /* a no op procedure for defaults */
  223. {
  224. }
  225.  
  226. char *ptoc(s)
  227. char *s;
  228. {
  229.     #ifndef MEGAMAX
  230.         return (PtoCstr(s));
  231.     #else
  232.         return (s);
  233.     #endif
  234. }
  235.  
  236. char *ctop(s)
  237. char *s;
  238. {
  239.     #ifndef MEGAMAX
  240.         return (CtoPstr(s));
  241.     #else
  242.         return (s);
  243.     #endif
  244. }
  245.  
  246. /* Given a menu name, find our data structure for it.  Return a Handle
  247.    to this structure.  This is a local procedure for SimpleTools use.
  248. */
  249.  
  250. /* local procedure */
  251.  
  252. menudatum **getourmenuhandle (name)
  253. char *name;                /* name of menu bar menu */
  254. {
  255.     menudatum **here, **temp;    /* hand to menu structure*/
  256.     here = simplemenus;
  257.  
  258.     /* find the menu name or the end of out menu list */
  259.     HLock (here);
  260.     while (strcmp(name,(**here).menuname) && (**here).next )  {
  261.         temp = here;
  262.         here = (menudatum **)(**here).next;
  263.         HUnlock (temp);
  264.         HLock (here);
  265.     }
  266.         
  267.     /* see if we found it or just the end of the list */
  268.     if (!strcmp(name,(**here).menuname)) {
  269.         HUnlock (here);
  270.         return (here);
  271.     } else {
  272.         HUnlock (here);
  273.         return ((menudatum **)0L);        
  274.     }
  275. }
  276.  
  277. /* This takes a Handle to our personal Item record and either a 
  278.    procedure name or a modifier code.  If it got a procedure name,
  279.    it sets it to the Item's procedure to run when the Item is chosen.
  280.    If it got a modifier code, it changes the state of the menu's Item
  281.    to checked, unchecked, enabled, or disabled.  It especially keeps 
  282.    track of the standard Edit menu items so we can restore them after
  283.    a desk accessory is finished.
  284. */
  285.  
  286. /* Local procedure */
  287.  
  288. setitems ( items, routine)    /* set a menu Item's routine or display */
  289. itemdatum    **items;    /* if items is neg, then whole menu     */
  290. ProcPtr    routine;
  291. {
  292.     int            inumber;
  293.     MenuHandle        mhand;
  294.     
  295.     /* check to see if a procedure pointer was given to us */
  296.     if ( (((long)items)>0L) && (routine > (ProcPtr)0x1000L)) {  
  297.                         /* good procedure value */
  298.         (**items).menurun = routine;
  299.         return;
  300.     }
  301.     
  302.     /* Calculate which Item number we are going to modify */
  303.     if ( (long)items < 0L) {        /* the whole menu     */
  304.         mhand = (MenuHandle) (0L - (long)items);
  305.         inumber = 0;
  306.     } else {                /* just one Item     */
  307.         mhand = (**items).menuhand;
  308.         inumber = (**items).itemno;
  309.     }
  310.  
  311.     /* If a NULL procedure pointer, then set to a no_op routine */
  312.     if ( (inumber > 0) && ((**items).menurun == (ProcPtr)0L) )
  313.         (**items).menurun = (ProcPtr) stnop;
  314.  
  315.     /* Now change the state of a menu Item */
  316.     switch ((int)routine) {
  317.         case itemdisable: 
  318.             DisableItem(mhand,inumber); break;
  319.         case itemenable:
  320.             EnableItem(mhand, inumber); break;
  321.         case itemcheck:
  322.             CheckItem(mhand, inumber, TRUE); break;
  323.         case itemuncheck:
  324.             CheckItem(mhand, inumber, FALSE); break;
  325.     }
  326.     if (inumber == 0) DrawMenuBar();  /* if main menu was changed     */
  327.     
  328. }
  329.  
  330. /* This routine is called by the simpletools() initial routine.  It gets
  331.    the pointer list of menus started, loads the desk accessories into
  332.    the Apple menu, and loads up some standard menu entries.  The reason
  333.    menu File has a New entry, and none others, is because as this code
  334.    currently stands, a menu must have at least one Item.  And since we
  335.    want File before Edit, I had to make an entry.  The most commonly used
  336.    Item under File is Quit.  But we like quit to be at the end of the list.
  337.    So, since New is usually always first when it is used, that the one
  338.    chosen to start File.  
  339. */
  340.  
  341. /* Local procedure */
  342.  
  343. initsmenus(about)            /* init simpletools' menus */
  344. char *about;
  345. {
  346.     itemdatum **items;
  347.  
  348.     simplemenus = (menudatum **) NewHandle ( (long)sizeof(menudatum));
  349.     HLock (simplemenus);
  350.  
  351.     strcpy ( (**simplemenus).menuname, applestring);
  352.     (**simplemenus).menuId = 1;
  353.     (**simplemenus).next = (Ptr) 0L;
  354.     ctop ((**simplemenus).menuname);
  355.     (**simplemenus).menuhand = NewMenu (1, (**simplemenus).menuname);
  356.     ptoc ((**simplemenus).menuname);
  357.     HUnlock ((**simplemenus).menuhand);
  358.  
  359.     (**simplemenus).itemlist = (itemdatum **)NewHandle ( 
  360.             (long)sizeof(itemdatum));
  361.     items = (itemdatum **) (**simplemenus).itemlist;
  362.     HLock (items);
  363.  
  364.     strcpy ((**items).itemname, about);
  365.     (**items).itemno = 1;
  366.     (**items).menuId = 1;
  367.     (**items).menuhand = (**simplemenus).menuhand;
  368.     (**items).menurun = (ProcPtr) stnop;
  369.     (**items).next = 0L;
  370.     HUnlock (items);
  371.  
  372.     ctop (about);
  373.     AppendMenu ((**simplemenus).menuhand, about);
  374.     ptoc (about);
  375.     DisableItem ((**simplemenus).menuhand, 1);
  376.     menu (applestring, "-", (ProcPtr) itemdisable);
  377.     #ifdef MEGAMAX
  378.       AddResMenu ((**simplemenus).menuhand, "DRVR");
  379.     #else
  380.       AddResMenu ((**simplemenus).menuhand, 'DRVR');
  381.     #endif
  382.     InsertMenu ((**simplemenus).menuhand, 0);
  383.     HUnlock (simplemenus);
  384.  
  385.     menu ("File", "New", (ProcPtr)itemdisable);
  386.     menu ("Edit", "Undo", stnop);
  387.     menu ("Edit", "-", (ProcPtr)itemdisable);
  388.     menu ("Edit", "Cut/X", stnop);
  389.     menu ("Edit", "Copy/C", stnop);
  390.     menu ("Edit", "Paste/V", stnop);
  391.     menu ("Edit", "Clear", stnop);
  392. }
  393.  
  394. /* Local procedure */
  395.  
  396. #ifndef LIGHTSPEED
  397. gottrans () 
  398. {
  399.   char prog[80];
  400.   char *argv[3];
  401.   if ( getfile("APPL", prog) ) {
  402.     argv[1] = NULL;
  403.     execv (prog, argv);
  404.   }
  405. }
  406. #endif
  407.  
  408. /* Local procedure */
  409.  
  410. gotquit ()
  411. {
  412.   ExitToShell();
  413. }
  414.  
  415. /* This routine is for the Windows menu Item.  The Windows menu is
  416.    set up when new windows are added.  It is used to bring forward and
  417.    bring into view windows that may be under other windows or have been
  418.    sent hiding by a click on their close box.
  419. */
  420.  
  421. /* Local procedure */
  422.  
  423. showawindow(name)            /* show the named window    */
  424. char *name;
  425. {
  426.     WindowPtr foo;
  427.     foo = windowpoint(name);    /* get its window pointer    */
  428.     if ( foo ) {
  429.         ShowWindow(foo);    /* show it on the screen    */
  430.         SetPort (foo);        /* set further output to it */
  431.         if ( foo != FrontWindow())    /* if it isn't active,    */
  432.             SelectWindow (foo);    /* activate it         */
  433.     }
  434. }
  435.  
  436. /* Local procedure */
  437.  
  438. winddatum **wdatum(windpt)        /* return Handle to window data */
  439. WindowPtr windpt;
  440. {
  441.     winddatum **wind, **temp;
  442.  
  443.     if (firstwind) return ((winddatum **) 0L);
  444.     wind = simplewinds;
  445.     HLock (wind);
  446.  
  447.     while ( ((**wind).wptr != windpt) && (**wind).next) {
  448.         temp = wind;
  449.         wind = (winddatum **) (**wind).next;
  450.         HUnlock (temp);
  451.         HLock (wind);
  452.     }
  453.  
  454.     if ( (**wind).wptr == windpt) {
  455.         HUnlock (wind);
  456.         return (wind);
  457.     } else {
  458.         HUnlock (wind);
  459.         return ((winddatum **) 0L);    /* zero if not found */
  460.     }
  461. }
  462.   
  463. /* Local procedure */
  464.  
  465. runruns(event)            /* run all the installed run procedures    */
  466. EventRecord *event;        /* returns number of routines run     */
  467. {
  468.     int i=0;
  469.     WindowPtr saveport;
  470.     GetPort (&saveport);
  471.     while ( simpleruns[i] )
  472.         (*(simpleruns[i++])) (event);
  473.     SetPort (saveport);
  474.     return(i);
  475. }
  476.  
  477. /* Local procedure */
  478.  
  479. stdialog( question, answer, type)  /* a general dialog displayer     */
  480. char *question;
  481. char *answer;
  482. int  type;            /* type:  1=prompt, 2=message         */
  483. {
  484.     DialogPtr dialog;    /* dialog reference             */
  485.     Handle Item, items;    /* handles for the dialog items     */
  486.     Rect screen, box;    /* rectangles for dialog/items         */
  487.     int dtype, hit, canc;    /* Item type and which was hit         */
  488.     char tempanswer[255];    /* address where answer is         */
  489.  
  490.     items = NewHandle (512L);/* get memory for items list         */
  491.     HLock (items);        /* lock it down             */
  492.     if (type == 1)
  493.         BlockMove (quesd, *items, (long) QUESN * 2L); 
  494.     else
  495.         BlockMove (messd, *items, (long) MESSN * 2L);
  496.     SetRect (&screen, 103, 50, 409, 137);        
  497.     
  498.     /* For LIGHTSPEED, use a lower case d and upper case B and P    */
  499.     /* for DBoxProc.  Megamax conversion utility does this wrong.    */
  500.     
  501.     dialog = NewDialog (0L, &screen, "", 0, dBoxProc, -1L, 0, 0L, items);
  502.     GetDItem (dialog, 2, &dtype, &Item, &box);
  503.     ctop (question);    
  504.     SetIText (Item, question);        /* set Item#2 text     */
  505.     ptoc (question);
  506.     if (type == 1) {            /* set default answer    */
  507.         GetDItem (dialog, 3, &dtype, &Item, &box);
  508.         ctop (answer);
  509.         SetIText (Item, answer);
  510.         ptoc (answer);
  511.         canc = 4;
  512.     } else
  513.         canc = 3;
  514.     ShowWindow (dialog);            /* display the dialog    */
  515.     do {
  516.         ModalDialog (0L, &hit);        /* process the dialog    */
  517.     } while ( (hit != 1) & (hit != canc) );
  518.     if (type == 1) {
  519.         GetDItem (dialog, 3, &dtype, &Item, &box);
  520.         HLock (Item);
  521.         GetIText (Item, tempanswer);    /* get Item#3 text     */
  522.         ptoc (tempanswer);
  523.         strcpy (answer, tempanswer);    /* make a copy of it     */
  524.         HUnlock (Item);
  525.     }
  526.     HUnlock(items);                /* unlock items memory    */
  527.     HPurge(items);                /* purge it         */
  528.     DisposDialog (dialog);            /* get rid of dialog    */
  529.     return ( hit==1 );            /* return true if ok    */
  530. }  
  531.   
  532. /* Local procedures */
  533.  
  534. docommand (which, thisevent)
  535. long which;
  536. EventRecord *thisevent;
  537. {
  538.     int themenu, theitem;
  539.     long size;
  540.     char *cpoint;
  541.     GrafPtr tempport;
  542.     menudatum **here, **temp;
  543.     itemdatum **items, **tempitems;
  544.     char **myreshandle;
  545.     Handle myhandle;
  546.   
  547.     themenu = HiWord (which);
  548.     theitem = LoWord (which);
  549.     if ((themenu == 1) && (theitem != 1)) {
  550.   
  551.         /* start up a desk accessory */
  552.         HLock (simplemenus);
  553.         GetItem ((**simplemenus).menuhand, theitem, accname);
  554.         SetResLoad (FALSE);
  555.         #ifdef MEGAMAX
  556.           myreshandle = GetNamedResource ("DRVR", accname);
  557.         #else
  558.           myreshandle = GetNamedResource ('DRVR', accname);
  559.         #endif
  560.         SetResLoad (TRUE);
  561.         size = SizeResource (myreshandle);
  562.         myhandle = NewHandle ( size + 3072L);
  563.         if (myhandle == 0L) 
  564.             message ("Not enough memory to do that.");
  565.         else {
  566.             DisposHandle (myhandle);
  567.             GetPort (&tempport);
  568.             OpenDeskAcc(accname);
  569.             SetPort (tempport);
  570.         }
  571.         HUnlock (simplemenus);
  572.         return;
  573.     }
  574.     if (themenu ==3) {
  575.         /* do any system edits */
  576.         if (SystemEdit(theitem -1))  return;
  577.     }
  578.   
  579.     /* now we run an installed menu procedure */
  580.     here = simplemenus;
  581.     HLock (here);
  582.   
  583.     /* find out menu structure given the menu id */
  584.     while ( ((**here).menuId != themenu) && (**here).next) {
  585.         temp = here;
  586.         here = (menudatum **)(**here).next;
  587.         HUnlock (temp);
  588.         HLock (here);
  589.     }
  590.   
  591.     if ((**here).menuId == themenu) {
  592.   
  593.         /* now find the Item structure */
  594.         items = (**here).itemlist;
  595.         HUnlock (here);
  596.         HLock (items);
  597.  
  598.         while ( ((**items).itemno != theitem) && (**items).next) {
  599.             tempitems = items;
  600.             items = (itemdatum **)(**items).next;
  601.             HUnlock (tempitems);
  602.             HLock (items);
  603.         }
  604.   
  605.         /* prepare to give the Item name to the procedure */
  606.         cpoint = (**items).itemname;
  607.         if ((**items).itemno == theitem) 
  608.         /* if we found the Item, call its procedure */
  609.             (*((**items).menurun))(cpoint,thisevent) ;
  610.         HUnlock (items);
  611.     }
  612. }
  613.  
  614. /* Local procedure */
  615.  
  616. domousedown(thisevent)        /* respond to mouse down events */
  617. EventRecord *thisevent;        /* passed the event record */
  618. {
  619.     WindowPtr whichwindow;
  620.     int code, x, y;
  621.     char *cpoint;
  622.     menudatum **omhand;
  623.     winddatum **thewdatum;
  624.     long newplace;
  625.     Point temp;
  626.     GrafPtr saveport;
  627.  
  628.     code = FindWindow(ZZ(thisevent->where), &whichwindow);
  629.     switch (code) {
  630.         case inMenuBar:
  631.         docommand(MenuSelect(ZZ(thisevent->where)),thisevent);
  632.         break;
  633.         case inSysWindow:
  634.         SystemClick(thisevent, whichwindow); break;
  635.         case inDrag:
  636.         DragWindow(whichwindow, ZZ(thisevent->where),
  637.             &dragrect); break;
  638.         case inGrow:
  639.         newplace= GrowWindow(whichwindow, ZZ(thisevent->where),
  640.             &sizerect);
  641.         SizeWindow(whichwindow, LoWord(newplace), 
  642.         HiWord(newplace), TRUE);
  643.         if (sizeredraw) {
  644.             GetPort (&saveport);
  645.             SetPort (whichwindow);
  646.             EraseRect (&swholescreen);
  647.             InvalRect (&swholescreen);
  648.             SetPort (saveport);
  649.         }
  650.         break;
  651.         case inGoAway:
  652.         if ( TrackGoAway(whichwindow, ZZ(thisevent->where))) {
  653.             HideWindow (whichwindow);
  654.         }
  655.         break;
  656.         case inzoomout:
  657.         case inzoomin:
  658.             #ifdef MEGAMAX
  659.           if ( trackbox(whichwindow, ZZ(thisevent->where), code)) {
  660.             zoomwindow (whichwindow, code, 0);
  661.         #else
  662.           if ( TrackBox(whichwindow, ZZ(thisevent->where), code)) {
  663.             ZoomWindow (whichwindow, code, 0);
  664.         #endif
  665.             GetPort (&saveport);
  666.             SetPort (whichwindow);
  667.             EraseRect (&swholescreen);
  668.             InvalRect (&swholescreen);
  669.             SetPort (saveport);
  670.         }
  671.         break;
  672.         case inContent:
  673.         
  674.         /* make the window active if it isn't yet */
  675.         if (whichwindow != FrontWindow()) {
  676.             SelectWindow(whichwindow);
  677.         }
  678.   
  679.         /* find our window data */
  680.         thewdatum = wdatum (whichwindow);
  681.         if (thewdatum) {
  682.           
  683.             /* convert the Point of click to the window's
  684.                own coordinates since this will be always
  685.                more useful than the global coordintates */
  686.             temp = thisevent->where;
  687.             SetPort (whichwindow);
  688.             GlobalToLocal (&temp);
  689.             #ifdef MEGAMAX
  690.               x = temp.a.h;
  691.               y = temp.a.v;
  692.             #else
  693.               x = temp.h;
  694.               y = temp.v;
  695.             #endif
  696.             
  697.             /* call the window's in content routine */
  698.             HLock (thewdatum);
  699.             (*((**thewdatum).wcontent))(x, y, whichwindow,
  700.                 thisevent);
  701.             HUnlock (thewdatum);
  702.         }
  703.         break;
  704.     }
  705. }
  706.             
  707.  
  708. /************************************************************************/
  709. /*     GLOBAL ROUTINES INTENDED TO BE USER CALLABLE PROCEDURES        */
  710. /* THE FOLLOWING PROCEDURES HAVE BEEN WRITTEN FOR THE USER'S         */
  711. /* APPLICATION TO CALL.                            */
  712. /*                                     */
  713. /************************************************************************/
  714.  
  715. havenewrom ()            /* returns true if new roms installed    */
  716. {
  717.     return ((*((int *)ROM85)) == NEWROM);
  718. }
  719.  
  720. /* Menu is usually called like:
  721.  
  722.         menu ("File", "Print...", got_print)
  723.         
  724.    where the first argument is the name appearing on the menubar.  The
  725.    2nd argument is the name appearing when the menu is pulled down.  The
  726.    3rd argument is USUALLY the routine to be called when the user
  727.    selects this particular menu.  Non-existant menus are created following
  728.    the last.  The menu ordering may never be changed once created.
  729.    Existint menus have their "routine-to-be-executed" assignment changed
  730.    to the new routine.  If the long values 0L, 1L, 2L, or 3L are passed
  731.    instead of a procedure, the menu characteristic is set as specified
  732.    by the constants itemdisable, itemenable, itemcheck, itemuncheck.  For
  733.    example:
  734.            menu ("File", "Print...", itemdisable)
  735.         
  736.    PROCEDURES ASSIGNED TO MENUS ARE CALLED WITH TWO ARGUMENTS.  YOU
  737.    DO NOT NEED TO DECLARE THESE IN YOUR PROCEDURE IF YOU DO NOT USE
  738.    THEM.  FOR EXAMPLE, GOT_PRINT MAY BE DECLARED AS:
  739.    
  740.            got_print()
  741.         char *itemname;
  742.         EventRecord *current_event;
  743.         {
  744.             ...
  745.         }
  746.         
  747.    Itemname is a char* pointing to the Item name.  This allows the same
  748.    menu procedure to be used for multiple menu/Item pairs.  Maybe your
  749.    Size menu just as items 9 Point, 10 Point, 12 Point, etc.  This way
  750.    you can specify the same procedure for each and determine what to do
  751.    by looking at itemname.  
  752.    
  753.    Current_event is a pointer to the current EventRecord that detected
  754.    the menu selection.  You may look at this as needed.
  755. */
  756.    
  757. menu (name, Item, routine)        /* install or change a menu    */
  758. char *name;                /* the menu name         */
  759. char *Item;                /* the Item name         */
  760. ProcPtr routine;            /* a procedure or modifier     */
  761. {
  762.     menudatum **here,**temp;    /* a roving Handle to our data     */
  763.     menudatum **ourmhandle;        /* another Handle to our data     */
  764.     itemdatum **items,**tempitems;    /* a Handle to the Item     */
  765.     int lastid, lastitem;
  766.     
  767.     /* get the Handle to menu named 'name' */
  768.     if ((ourmhandle = getourmenuhandle (name)) == 0L) {
  769.     
  770.         /* make a new menu entry by finding the end of the list */
  771.         here = simplemenus;
  772.         HLock (here);
  773.         while ((**here).next) {
  774.             temp = here;
  775.             here = (menudatum **)(**here).next;
  776.             HUnlock (temp);
  777.             HLock (here);
  778.         }
  779.             
  780.         /* make a structure for our new entry */
  781.         lastid = (**here).menuId;
  782.         (**here).next = (Ptr)NewHandle ( (long)sizeof(menudatum));
  783.         temp = here;
  784.         here = (menudatum **)(**here).next;
  785.         HUnlock (temp);
  786.         HLock (here);
  787.  
  788.         strcpy ( (**here).menuname, name);
  789.         (**here).menuId = ++lastid;
  790.         (**here).next = (Ptr) 0L;
  791.         
  792.         /* make a new Item structure */
  793.         (**here).itemlist = (itemdatum **)NewHandle ( 
  794.             (long)sizeof(itemdatum));
  795.             
  796.         /* make a new menu entry for the Macintosh */
  797.         ctop (name);
  798.         (**here).menuhand = NewMenu (lastid, name);
  799.         ptoc (name);
  800.         items = (**here).itemlist;
  801.  
  802.         HLock (items);
  803.         strcpy ((**items).itemname, Item);
  804.         (**items).itemno = 1;
  805.         (**items).menuId = lastid;
  806.         (**items).menuhand = (**here).menuhand;
  807.         (**items).menurun = (ProcPtr) 0L;
  808.         (**items).next = 0L;
  809.         HUnlock (items);
  810.         
  811.         /* install and display the menu */
  812.         ctop (Item);
  813.         AppendMenu ((**here).menuhand, Item);
  814.         ptoc (Item);
  815.         InsertMenu ((**here).menuhand,0);
  816.         HUnlock (here);
  817.  
  818.         setitems (items, routine);
  819.         DrawMenuBar();
  820.         return(TRUE);
  821.     }
  822.     else {
  823.         HLock (ourmhandle);
  824.  
  825.         if (strlen(Item) == 0) {
  826.           /* then adjust main menu */
  827.           setitems( 0L - (long) ((**ourmhandle).menuhand), routine);
  828.           return(FALSE);
  829.         }
  830.  
  831.         /* see if Item is in list */
  832.         items = (**ourmhandle).itemlist;
  833.         HLock (items);
  834.  
  835.         while ( strcmp(Item,(**items).itemname) && (**items).next) {
  836.             tempitems = items;
  837.             items = (itemdatum **)(**items).next;
  838.             HUnlock (tempitems);
  839.             HLock (items);
  840.         }
  841.         if (strcmp(Item,(**items).itemname) ==0) {
  842.             setitems( items, routine);
  843.             return(FALSE);
  844.         }
  845.         else {
  846.             /* make new Item entry */
  847.             lastitem = (**items).itemno;
  848.             (**items).next =(Ptr)NewHandle((long)sizeof(itemdatum));
  849.             tempitems = items;
  850.             items = (itemdatum **)(**items).next;
  851.             HUnlock (tempitems);
  852.             HLock (items);
  853.  
  854.             strcpy ((**items).itemname, Item);
  855.             (**items).itemno = ++lastitem;
  856.             (**items).menuId = (**ourmhandle).menuId;
  857.             (**items).menuhand = (**ourmhandle).menuhand;
  858.             (**items).menurun = (ProcPtr) 0L;
  859.             (**items).next = 0L;
  860.             HUnlock (items);
  861.  
  862.             /* and install the Item in the menu bar */
  863.             ctop (Item);
  864.             AppendMenu ((**ourmhandle).menuhand,Item);
  865.             ptoc (Item);
  866.             HUnlock (ourmhandle);
  867.             setitems (items, routine);
  868.             return(TRUE);
  869.         }
  870.     }
  871. }
  872.  
  873. /* Given a menu name, return the real menu Handle as used by most
  874.    of the Macintosh toolbox menu manager routines.
  875. */
  876.  
  877. MenuHandle mhand (name)            /* find MenuHandle        */
  878. char *name;                /* given name of menu         */
  879. {
  880.     menudatum    **menu;    
  881.     MenuHandle    temp;        /* a Handle to our data     */
  882.  
  883.     menu = getourmenuhandle(name);
  884.     if ( menu ) {
  885.         HLock (menu);
  886.         temp = (**menu).menuhand;
  887.         HUnlock (menu);
  888.         return ( temp );    /* return menu Handle         */
  889.     } else
  890.         return ( (MenuHandle) 0 );    
  891. }
  892.  
  893.     
  894. /*  Call this routine if you want these SimpleTools defined quiting    */
  895. /*  procedures.  You may just install your own instead.     The time to    */
  896. /*  call this is after you have installed all your other "File" items.    */
  897. /*  By calling this last, you will place Transfer and Quit on the end    */
  898. /*  of the menu list.                            */
  899.  
  900. simplequits ()
  901. {
  902.     menu ("File", "-", itemdisable);
  903.     
  904.     #ifndef LIGHTSPEED
  905.     menu ("File", "Transfer.../T", gottrans);
  906.     #endif
  907.     
  908.     menu ("File", "Quit/Q", gotquit);
  909. }
  910.  
  911. /* Given a window's name, return its window pointer so that other
  912.    Macintosh Window Manager routines can be called for that window. */
  913.  
  914. WindowPtr windowpoint(name)        /* get window pointer         */
  915. char *name;                /* given window's name         */
  916. {
  917.     winddatum **wind, **tempwind;    /* Handle to our window data     */
  918.     WindowPtr    temp;
  919.  
  920.     if (firstwind) return ((WindowPtr)0); 
  921.     wind = simplewinds;        /* look for the named window     */
  922.     HLock (wind);
  923.  
  924.     while ( strcmp ((**wind).windname, name) && (**wind).next) {
  925.         tempwind = wind;
  926.         wind = (winddatum **) (**wind).next;
  927.         HUnlock (tempwind);
  928.         HLock (wind);
  929.     }
  930.     if ( strcmp ((**wind).windname, name) ==0) {
  931.         temp = (**wind).wptr;
  932.         HUnlock (wind);
  933.         return ( temp );    /* return pointer        */
  934.     } else {
  935.         HUnlock (wind);
  936.         return ( (WindowPtr) 0);/* or zero if it wasn't found    */
  937.     }
  938. }
  939.  
  940. /* This routine installs a new window onto the screen.  It also gives
  941.    that window an Item in the Window menu.  This routine is also used
  942.    to modify a window's associated routines.  The x,y positions are the
  943.    top left and bottom right corners of where the window should originally
  944.    be placed.  The coordinates are never used when this routine is called
  945.    to update an already existing window.  But the spaces must be filled,
  946.    so you can use zeros if you want.  Once the window has been displayed in
  947.    its original position, the user has complete control of its size and
  948.    placement with the mouse.
  949.    
  950.    YOU MUST ASSIGN PROCEDURES TO BE CALLED WHEN SIMPLETOOLS DETECTS THAT
  951.    THIS WINDOW IS BECOMMING ACTIVE, DEACTIVATING, NEEDS UPDATING, OR
  952.    THE MOUSE HAS BEEN PRESSED IN ITS CONTENT.  JUST LIKE THE MENU PROCEDURE,
  953.    THESE PROCEDURES ARE PASSED SOME ARGUMENTS.  YOU DO NOT HAVE TO 
  954.    DECLARE THESE IF YOU DON'T WHAT TO USE THEM.  IF YOU USE THE ARGUMENTS,
  955.    YOU WOULD DECLAR THESE PROCEDURES AS FOLLOWS:
  956.    
  957.        my_activate (windp, event)    same as my_update
  958.     my_deactivate (windp, event)    same as my_update
  959.     
  960.     my_update (windp, event)
  961.     WindowPtr     windp;        the window being acted upon
  962.     EventRecord     *event;        the current event record
  963.     {
  964.         ...
  965.     }
  966.     
  967.     my_inContent (x, y, windp, event)
  968.     int         x, y;        mouse position in local coords
  969.     WindowPtr     windp;        like above
  970.     EventRecord     *event;        like above
  971.     {
  972.         ...
  973.     }
  974. */
  975.  
  976. window(name, xtop, ytop, xbot, ybot, a, d, u, c)
  977. char *name;            /* window's name             */
  978. int xtop, ytop, xbot, ybot;    /* position if this is a new window     */
  979. ProcPtr a, d, u, c;        /* activate, deactivate, update, and     */
  980. {                /*  content procedures          */
  981.     winddatum **wind, **temp;/* Handle to our window data         */
  982.     winddatum **newentry;    /* another Handle             */
  983.     Rect newplace;        /* rectable for the window's placement    */
  984.  
  985.     if (a == (ProcPtr) 0)
  986.         a = (ProcPtr) stnop;
  987.     if (d == (ProcPtr) 0)
  988.         d = (ProcPtr) stnop;
  989.     if (u == (ProcPtr) 0)
  990.         u = (ProcPtr) stnop;
  991.     if (c == (ProcPtr) 0)
  992.         c = (ProcPtr) stnop;
  993.     if ( !firstwind ) {
  994.  
  995.         /* see if window is in the list */
  996.         wind = simplewinds;
  997.         HLock (wind);
  998.  
  999.         while ( strcmp ((**wind).windname, name) && (**wind).next) {
  1000.             temp = wind;
  1001.             wind = (winddatum **) (**wind).next;
  1002.             HUnlock (temp);
  1003.             HLock (wind);
  1004.         }
  1005.         if ( strcmp ((**wind).windname, name) ==0) {
  1006.  
  1007.             /* reset the found window's parameters */
  1008.             (**wind).wact = (ProcPtr) a;
  1009.             (**wind).wdeact = (ProcPtr) d;
  1010.             (**wind).wupdate = (ProcPtr) u;
  1011.             (**wind).wcontent = (ProcPtr) c;
  1012.             SetPort ( (**wind).wptr);        
  1013.             HUnlock (wind);
  1014.  
  1015.             return(FALSE);
  1016.         }
  1017.         HUnlock (wind);
  1018.     }
  1019.  
  1020.     /* make a new window entry */
  1021.     newentry = (winddatum **)NewHandle ( (long) sizeof (winddatum));
  1022.     if (firstwind)
  1023.         simplewinds = newentry;
  1024.     else
  1025.         (**wind).next = (Ptr) newentry;
  1026.     firstwind = 0;
  1027.     HLock (newentry);
  1028.  
  1029.     strcpy ((**newentry).windname, name);
  1030.     SetRect (&newplace, xtop, ytop, xbot, ybot);
  1031.     if (EmptyRect (&newplace)) 
  1032.         SetRect (&newplace, 10, 42, 500, 330);
  1033.     ctop (name);
  1034.     (**newentry).wptr = NewWindow (0L, &newplace, name, show_new_window, 
  1035.         wprocid, -1L, dogoaway, newentry);
  1036.     ptoc (name);
  1037.     (**newentry).wact = (ProcPtr) a;
  1038.     (**newentry).wdeact = (ProcPtr) d;
  1039.     (**newentry).wupdate = (ProcPtr) u;
  1040.     (**newentry).wcontent = (ProcPtr) c;
  1041.     (**newentry).next = (Ptr) 0;
  1042.     if (windmenu)
  1043.         menu ("Windows", name, showawindow); 
  1044.     SetPort ( (**newentry).wptr);        
  1045.     HUnlock (newentry);
  1046.  
  1047.     return(TRUE);
  1048. }
  1049.  
  1050. withwindow(name)            /* set output to window by name    */
  1051. char *name;                /* give it the window's name     */
  1052. {                    /* returns if window exists    */
  1053.     winddatum **wind, **temp;
  1054.     wind = simplewinds;
  1055.     if (firstwind) return(FALSE);    /* search for the window's name */
  1056.  
  1057.     HLock (wind);
  1058.     while ( strcmp ((**wind).windname, name) && (**wind).next) {
  1059.         temp = wind;
  1060.         wind = (winddatum **) (**wind).next;
  1061.         HUnlock (temp);
  1062.         HLock (wind);
  1063.     }
  1064.     if ( strcmp ((**wind).windname, name) ==0) {
  1065.         SetPort ( (**wind).wptr);    /* set output to it     */
  1066.         HUnlock (wind);
  1067.         return(TRUE);
  1068.     } else {
  1069.         HUnlock (wind);
  1070.         return(FALSE);
  1071.     }
  1072. }
  1073.   
  1074. /* This run procedure is used to install routines to be occasionally
  1075.    run.  The routine will be run once for each call to simpleevents()
  1076.    which is done repeatedly by runsimpletools().
  1077.    
  1078.    EACH ROUTINE INSERTED INTO THE RUN LIST IS RUN MULTIPLE TIMES UNTIL
  1079.    IT IS REMOVED BY CALLING STOP.  THE ROUTINE IS CALLED WITH A SINGLE
  1080.    ARGUMENT, A POINTER TO THE EVENT JUST RETURNED BY GETNEXTEVENT() AND
  1081.    BEFORE SIMPLETOOLS PROCESSES IT.
  1082. */
  1083.  
  1084. run(routine)            /* install a run procedure     */
  1085. ProcPtr routine;        /* give it the procedure     */
  1086. {                /* return TRUE if successful     */
  1087.     int i;
  1088.     i = 0;            /* add it to the end of the list */
  1089.     while ( simpleruns[i] != (ProcPtr) 0L) i++;
  1090.     if (i < maxsruns) {
  1091.         simpleruns[i] = routine;
  1092.         simpleruns[i+1] = (ProcPtr) 0L;
  1093.         return(TRUE);
  1094.     } else
  1095.         return(FALSE);
  1096. }
  1097.  
  1098. /* This routine removes a procedure from the list of run procedures */
  1099.  
  1100. stop(routine)            /* stop a procedure from running*/
  1101. ProcPtr routine;        /* give the procedure         */
  1102. {                /* return TRUE if successful     */
  1103.     int i = 0;
  1104.     while ( (simpleruns[i] != routine) && simpleruns[i])  i++;
  1105.     if (simpleruns[i]) {
  1106.         while ( simpleruns[i] != (ProcPtr)0 ) {
  1107.             simpleruns[i] = simpleruns[i+1];
  1108.             i++;
  1109.         }
  1110.         return(TRUE);
  1111.     } else {
  1112.         return(FALSE);
  1113.     }
  1114. }
  1115.  
  1116. void home ()            /* text-based home of the pen with
  1117.                    the window being erased.        */
  1118. {
  1119.     GrafPtr    port;
  1120.     GetPort (&port);
  1121.     EraseRect (&(port->portRect));
  1122.     stgotoxy (1, 1);
  1123. }
  1124.  
  1125. stgotoxy (x, y)                /* goto text position x, y    */
  1126. int x, y;    
  1127. {
  1128.     Point        pt;
  1129.     int        newx, newy;
  1130.     FontInfo    font;
  1131.   
  1132.     GetFontInfo (&font);
  1133.     GetPen (&pt);
  1134.     #ifdef MEGAMAX
  1135.     if (x < 0) 
  1136.         newx = pt.a.h;
  1137.     else
  1138.         newx = font.widMax * (x);
  1139.     if (y < 0)
  1140.         newy = pt.a.v;
  1141.     #else
  1142.     if (x < 0) 
  1143.         newx = pt.h;
  1144.     else
  1145.         newx = font.widMax * (x);
  1146.     if (y < 0)
  1147.         newy = pt.v;
  1148.     #endif
  1149.     else
  1150.         newy = (font.ascent + font.descent + font.leading) * (y+1);
  1151.     MoveTo (newx, newy);
  1152. }
  1153.  
  1154. /* The getline procedure is to be called when you want to simply get a Line
  1155.    of text from the user at the current pen position on the screen.  You
  1156.    will probably preceed this with a call to stgotoxy(x,y).  You would call
  1157.    it like:    
  1158.            getline ("Erik", name);
  1159.         
  1160.    where name is a character array.  This works MUCH better than scanf()
  1161.    or gets() since it uses the Macintosh TextEdit routines to allow the
  1162.    user to edit the Line being input.
  1163.    
  1164.    Getline is very "modal" and no other events are handled while the
  1165.    user is expected to enter the Line.  Getline returns ONLY when the
  1166.    user presses <RETURN>.  
  1167.    
  1168.    Routines scheduled to run by the run() routine are called.  Make sure
  1169.    your run routines don't strip all <RETURNS> from the event record
  1170.    they get or getline will never stop.
  1171. */
  1172.    
  1173. getline (dfault, destination)        /* using TE, get a Line        */
  1174. char *dfault, *destination;        /* default string, dest     */
  1175. {
  1176.     TEHandle         hte;
  1177.     Rect            destRect;
  1178.     Point            pen,pt;
  1179.     FontInfo        FInfo;
  1180.     int            done, mask, code, in_already, nextcap;
  1181.     GrafPtr            port, window;
  1182.     EventRecord        event;
  1183.     char            key;
  1184.     CursHandle        c;
  1185.     
  1186.     GetPort (&port);        /* Calculate Rect for TE    */
  1187.     if (port != FrontWindow())  SelectWindow (port);
  1188.     GetPen (&pen);
  1189.     GetFontInfo (&FInfo);
  1190.     #ifdef MEGAMAX
  1191.         SetRect (&destRect, pen.a.h, pen.a.v - FInfo.ascent,
  1192.             1000, pen.a.v + FInfo.descent);
  1193.     #else
  1194.         SetRect (&destRect, pen.h - 1, pen.v - FInfo.ascent,
  1195.             1000, pen.v + FInfo.descent);
  1196.     #endif
  1197.     EraseRect (&destRect);
  1198.     hte = TENew (&destRect, &destRect);    
  1199.     TESetText (dfault, (long)strlen(dfault), hte);
  1200.     TEActivate (hte);
  1201.     TEUpdate (&destRect, hte);
  1202.     mask = mDownMask + keyDownMask + autoKeyMask + mUpMask;
  1203.     done = FALSE;
  1204.     #ifdef MEGAMAX
  1205.       c = GetCursor (ibeamcursor);
  1206.     #else
  1207.       c = GetCursor (iBeamCursor);
  1208.     #endif
  1209.     in_already = FALSE;
  1210.     nextcap = getlinecaps;
  1211.     do {                /* "modal" loop until <cr>    */
  1212.         SystemTask ();
  1213.         TEIdle (hte);
  1214.         
  1215.         GetNextEvent (mask, &event);
  1216.         runruns (&event);
  1217.         GetMouse (&pt);        /* use I beam in TE        */
  1218.         if (PtInRect (ZZ(pt), &destRect)) {
  1219.           if ( ! in_already )  {
  1220.              SetCursor (*c);
  1221.              in_already = TRUE;
  1222.           }
  1223.         } else {
  1224.           if ( in_already ) {
  1225.               InitCursor ();
  1226.               in_already = FALSE;
  1227.           }
  1228.         }
  1229.         switch (event.what) {
  1230.             case mouseDown:
  1231.             code = FindWindow (ZZ(event.where),&window);
  1232.             if ((code == inContent) && (window == port)) {
  1233.                GlobalToLocal (&event.where);
  1234.                 if (PtInRect(ZZ(event.where),&destRect))
  1235.                     TEClick (ZZ(event.where), 0, hte);
  1236.                 else SysBeep (1);
  1237.             } else SysBeep (20);
  1238.             break;
  1239.             case keyDown:
  1240.             case autoKey:
  1241.                 key = (char) (event.message & 0xFFL);
  1242.             if (nextcap && (key >= 'a') && (key <= 'z')) 
  1243.                 key -= ' ';
  1244.             nextcap = FALSE;
  1245.             if (key == ' ') nextcap = getlinecaps;
  1246.             if (key != '\r')  TEKey (key, hte);
  1247.             else  done = TRUE;
  1248.             break;
  1249.         }
  1250.     } while (!done);
  1251.     TEDeactivate (hte);
  1252.     
  1253.     /* For LIGHTSPEED, use a lowercase te and upper case L in    */
  1254.     /* TElength.  Megamax conversion utility does this wrong too.    */
  1255.     
  1256.     strncpy (destination, *TEGetText(hte), (*hte)->teLength);
  1257.     destination[(*hte)->teLength] = 0;
  1258.  
  1259.     TEDispose (hte);
  1260.         InitCursor ();
  1261. }
  1262.  
  1263. /*  Use prompt when you want a tiny window to pop up to ask the user
  1264.     a question.  The question is drawn and a TextEdit box is provided
  1265.     to get the answer.  Whatever the user leaves in the answer box
  1266.     is returned in answer.  Two buttons are also displayed:  OK and
  1267.     CANCEL.  Prompt returns TRUE or FALSE depending on which Button was
  1268.     pressed.
  1269. */
  1270.  
  1271. prompt ( question, answer)        /* dialog box question/answer */
  1272. char *question;
  1273. char *answer;
  1274. {
  1275.     return (stdialog (question, answer, 1));
  1276. }
  1277.  
  1278. /* Message is just like prompt except no answer box is displayed.  An
  1279.    OK and CANCEL Button works just like prompt.
  1280. */
  1281.  
  1282. message ( message )            /* dialog box message         */
  1283. char *message;
  1284. {
  1285.     return (stdialog (message, message, 2));
  1286. }
  1287.   
  1288. /*  This routine is a simpler whay to call the toolbox SFGetFile()
  1289.     routine.  Simple call this like:
  1290.     
  1291.             getfile ("TEXT", filename)
  1292.         
  1293.     where filename is a character array.  Replace TEXT with whatever
  1294.     file type you desire.  The file manager's working directory is set
  1295.     correctly so that a subsequent open() call with filename will work.
  1296. */
  1297.  
  1298. getfile (ftype, reply)
  1299. char ftype[];
  1300. char reply[];
  1301. {
  1302.     Point where;
  1303.     SFReply frommac;
  1304.     
  1305.     #ifdef MEGAMAX
  1306.       where.a.h = 75; where.a.v = 50;
  1307.     #else
  1308.       where.h = 75; where.v = 50;
  1309.     #endif
  1310.     if (strlen(ftype) != 4)
  1311.       SFGetFile (ZZ(where), NULL, NULL, -1, NULL, NULL, &frommac);
  1312.     else
  1313.       SFGetFile (ZZ(where), NULL, NULL, 1, ftype, 0L, &frommac);
  1314.     if (frommac.good) {
  1315.       SetVol ("", frommac.vRefNum);
  1316.       strcpy (reply, frommac.fName);
  1317.       return (TRUE);
  1318.     }
  1319.     else return (FALSE);
  1320. }
  1321.  
  1322. /* This is like getfile, but may get a new file name from the user.
  1323.    Origname is the default you want to present to the user.
  1324. */
  1325.  
  1326. putfile (origname,reply)
  1327. char *origname;
  1328. SFReply *reply;
  1329. {
  1330.     Point where;
  1331.     SFReply frommac;
  1332.     
  1333.     #ifdef MEGAMAX
  1334.       where.a.h = 75; where.a.v = 50;
  1335.     #else
  1336.       where.h = 75; where.v = 50;
  1337.     #endif
  1338.     SFPutFile (ZZ(where), "", origname, 0L, &frommac);
  1339.     if (frommac.good) {
  1340.       SetVol ("", frommac.vRefNum);
  1341.       strcpy (reply, frommac.fName);
  1342.       return (TRUE);
  1343.     }
  1344.     return (FALSE);
  1345. }
  1346.  
  1347. /* This routine initializes SimpleTools and MUST be called before    */
  1348. /* most of the other SimpleTools routines are called.            */
  1349. /* The passed about string is the menu Item name to appear just under    */
  1350. /* the Apple menu.  This will be disabled and can be enabled using    */
  1351. /* a menu() call.  This routine also initializes the Macintosh         */
  1352. /* for application execution and desk accessory processing.        */
  1353.  
  1354. simpletools(about)    /* to be called at the beginning of program     */
  1355. char *about;
  1356. {
  1357.     #ifdef MEGAMAX
  1358.       maxapplzone();    /* allow maximum heap expansion     */
  1359.     #else
  1360.       MaxApplZone();
  1361.     #endif
  1362.     FlushEvents (everyEvent,0);  /* ignore left over events     */
  1363.     InitGraf (&thePort);    /* initialize the screen         */
  1364.     InitFonts();        
  1365.     InitWindows();
  1366.     InitMenus();
  1367.     InitCursor();        /* make the arrow Cursor         */
  1368.     TEInit();
  1369.     InitDialogs(gotquit);
  1370.     snewrom = havenewrom();
  1371.     
  1372.     /* Ugh.  For LightSpeed use a lower case d in DocumentProc.    */
  1373.     /* Megamax conversion utility is at fault here.            */
  1374.     
  1375.     wprocid = documentProc;
  1376.     if (snewrom) wprocid = zoomproc;
  1377.     SetRect ( &sizerect, 20, 50, 250, 330);
  1378.     simpleruns[0] = (ProcPtr) 0;  /* empty the run list         */
  1379.  
  1380.     /* These are the bounds we are allowed to size a window or
  1381.        Move a window to.  
  1382.     */
  1383.  
  1384.     swholescreen = dragrect = thePort -> portRect;
  1385.     InsetRect (&dragrect, 4, 4);
  1386.     SetRect ( &sizerect, 20, 20, 2048, 700);
  1387.     firstwind = 1;            /* empty window table        */
  1388.     keydownproc = (ProcPtr) stnop;    /* default key hit procedures     */
  1389.     autokeyproc = (ProcPtr) stnop;
  1390.     initsmenus(about);        /* install the menus         */
  1391. }
  1392.  
  1393. simpleevents()                /* to be called in the main loop */
  1394. {
  1395.     EventRecord newevent;
  1396.     winddatum **thewdatum;
  1397.     SystemTask();            /* Do the system D.A. etc. stuff */
  1398.     HiliteMenu(0);
  1399.     GetNextEvent(everyEvent, &newevent);
  1400.     runruns(&newevent);        /* Do our run procedures     */
  1401.     switch (newevent.what) {
  1402.         case mouseDown:
  1403.         domousedown(&newevent); break;
  1404.         case keyDown: 
  1405.         if (newevent.modifiers & cmdKey)
  1406.             docommand(MenuKey((char)(newevent.message & 0xffL)),
  1407.                 &newevent);
  1408.         (*(keydownproc))(&newevent);
  1409.          break;
  1410.         case autoKey: 
  1411.         if (newevent.modifiers & cmdKey)
  1412.             docommand(MenuKey((char)(newevent.message & 0xffL)),
  1413.                 &newevent);
  1414.         (*(autokeyproc))(&newevent);
  1415.         break;
  1416.         case activateEvt: 
  1417.         thewdatum = wdatum(newevent.message);
  1418.         if (thewdatum) {
  1419.             SetPort(newevent.message);
  1420.             HLock (thewdatum);
  1421.             if (newevent.modifiers & 1) {
  1422.  
  1423.                 (*((**thewdatum).wact))(newevent.message, 
  1424.                     &newevent);
  1425.             } else {
  1426.                 (*((**thewdatum).wdeact))(newevent.message,
  1427.                     &newevent);
  1428.             }
  1429.             HUnlock (thewdatum);
  1430.         }
  1431.         break;
  1432.         case updateEvt:
  1433.         thewdatum = wdatum(newevent.message);
  1434.         if (thewdatum) {
  1435.             SetPort (newevent.message);
  1436.             BeginUpdate (newevent.message);
  1437.             HLock (thewdatum);
  1438.             (*((**thewdatum).wupdate))(newevent.message,
  1439.                 &newevent);
  1440.             HUnlock (thewdatum);
  1441.             EndUpdate (newevent.message);
  1442.         }
  1443.         break;
  1444.     }
  1445. }
  1446.  
  1447. runsimpletools ()
  1448. {
  1449.     for (;;) simpleevents();
  1450. }
  1451.  
  1452.